/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package modele;

import modele.combinaison.Combinaison;
import modele.combinaison.CombinaisonComplexe;
import modele.combinaison.PetiteSuite;
import modele.combinaison.Yams;
import modele.combinaison.Deux;
import modele.combinaison.Cinq;
import modele.combinaison.As;
import modele.combinaison.Carre;
import modele.combinaison.Brelan;
import modele.combinaison.GrandeSuite;
import modele.combinaison.Full;
import modele.combinaison.Six;
import modele.combinaison.Trois;
import modele.combinaison.Quatre;
import exception.CombinaisonInconnue;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import modele.combinaison.Chance;

/**
 * Classe qui correspond à la feuille de score de chaque joueur
 * @author Florian MININ & Khémon BEH
 */
public class FeuilleScore implements Iterable<Combinaison>{
    
    //Variable d'instance qui correspond à la prime de 35 points accordé
    //si le sous total est supérieur ou égal à 63 points
    public static final int PRIME = 35;
    private Map<Combinaison, Integer> mapCombi;
    private int scoreCombisSimple;
    private int scoreCombiComplexe;
    private int nombreCombiRestante;

    /**
     * Constructeur
     */
    public FeuilleScore(){
        scoreCombisSimple = 0;
        scoreCombiComplexe = 0;
        mapCombi = new LinkedHashMap<Combinaison, Integer>();
        initialiseFeuilleScore();
    }


    /**
     * Méthode privée appelée dans le constructeur pour initialisée
     * la feuille de score
     */
    private void initialiseFeuilleScore(){
        //On initialise la feuille de score avec
        //toutes les combinaisons en clé. Et les valeurs initialisées à 0
        mapCombi.put(new As(),0);
        mapCombi.put(new Deux(),0);
        mapCombi.put(new Trois(),0);
        mapCombi.put(new Quatre(),0);
        mapCombi.put(new Cinq(),0);
        mapCombi.put(new Six(),0);
        mapCombi.put(new Brelan(),0);
        mapCombi.put(new Carre(), 0);
        mapCombi.put(new Full(), 0);
        mapCombi.put(new PetiteSuite(), 0);
        mapCombi.put(new GrandeSuite(), 0);
        mapCombi.put(new Yams(), 0);
        mapCombi.put(new Chance(), 0);
        //Le nombre de combinaison à faire est égal à la taille de la map
        nombreCombiRestante = mapCombi.size();
    }

    public int scoreTotal() {
        return scoreCombisSimple>=63?
            scoreCombisSimple+scoreCombiComplexe+PRIME :
            scoreCombisSimple+scoreCombiComplexe;
    }

    public Entry<Combinaison,Integer> getCombinaison(String combi) throws CombinaisonInconnue {
        for(Entry<Combinaison,Integer> couple : mapCombi.entrySet()){
            if(couple.getKey().getNomCombinaison().equals(combi)){
                return couple;
            }
        }
        throw new CombinaisonInconnue();
    }

    public void calculeScore() {
        Combinaison tempCombi;
        String typeCombi;
        scoreCombiComplexe =0;
        scoreCombisSimple = 0;
        for(Entry<Combinaison,Integer> couple : mapCombi.entrySet()){
            tempCombi = couple.getKey();
            typeCombi = tempCombi.getTypeCombinaison();
            if(typeCombi.equals(CombinaisonComplexe.COMBINAISON_COMPLEXE)){
                scoreCombiComplexe += couple.getValue();
            } else {
                scoreCombisSimple += couple.getValue();
            }
        }
    }

    /**
     * Décrémente de 1 le nombre de combi à faire
     */
    public void decrementeCombisRestante() {
        --nombreCombiRestante;
    }


    int getNbCombiRestante() {
        return nombreCombiRestante;
    }


    public Iterator<Combinaison> iterator() {
        return new itr();
    }


    private class itr implements Iterator<Combinaison> {
        // Variable d'instances nécessaire au parcours
        Set ensembleCombinaisons = mapCombi.entrySet();
        Iterator<Entry<Combinaison,Integer>> it = mapCombi.entrySet().iterator();
        Combinaison c;

        /**
         * Vérifie si il reste des élément a parcourir.
         * @return : Retourne vrai si il reste des éléments. Faux sinon.
         */
        public boolean hasNext() {
            // Traitement pour déterminer s'il y a encore des élements a
            // parcourir
            return (it.hasNext());
        }

        /**
         * Passe a l'élément suivant et affiche l'élément courant.
         * @return : L'élément courant a afficher.
         */
        public Combinaison next() {
            return it.next().getKey();
        }

        /**
         * Retire le sommet de la pile.
         */
        public void remove() {
            // Nom implémenté
        }
    }


}
